/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */


import weka.core.Instances;
import weka.core.Instance;
import weka.core.Attribute;
import weka.core.AttributeStats;
import weka.core.Utils;

import java.util.Enumeration;
import java.util.ArrayList;

/**
 *
 * @author mgomez/frpp
 */
public class TDIDTUtils {
    /**
     * Parte un conjunto de datos de acuerdo a los valores 
     * de un atributo
     *
     * @param data conjunto de datos a partir de los que se
     * aprende
     * @param att atributo a usar para el particionado
     * @return conjuntos de instancias (uno por valor del
     * atributo)
     */
    public static Instances[] splitData(Instances data, Attribute att) {

        // Se crean un array preparado para almacenar los
        // conjuntos de datos formados
        Instances[] splitData = new Instances[att.numValues()];
        
        // Se crean los conjuntos de datos inicialmente vacios
        // y se almacenan en el array
        for (int j = 0; j < att.numValues(); j++) {
            splitData[j] = new Instances(data, data.numInstances());
        }
        
        // Se recorren las instancias una a una
        Enumeration instEnum = data.enumerateInstances();
        
        // Mientras queden instancias por considerar
        while (instEnum.hasMoreElements()) {
            // Se considera la siguiente instancia
            Instance inst = (Instance) instEnum.nextElement();
            
            // Se introduce en el conjunto de datos conveniente
            splitData[(int) inst.value(att)].add(inst);
        }
        
        // Al final se compactan los conjuntos de datos, para
        // dimensionarlos al numero de instancisa disponibles
        for (int i = 0; i < splitData.length; i++) {
            splitData[i].compactify();
        }
        
        // Se devuelve el array con los conjuntos de datos
        return splitData;
    } 
    
    /**
     * Metodo que obtiene los atributos aun por usar para particionado,
     * teniendo en cuenta el conjunto de instancias a usar y el nodo
     * que esta siendo expandido actualmente
     */
    public static ArrayList<Attribute> getUnusedAttributes(Instances data, 
            TDIDTTree nodeUnderConsideration){
        // Se construye el array inicial de atributos usados
        ArrayList<Attribute> used=new ArrayList<Attribute>();
        
        // Se considera el padre del nodo en consideracion
        TDIDTTree parentNode=nodeUnderConsideration.getParent();
        
        // Mientras el padre no sea null, agrega su atributo
        while(parentNode != null){
            used.add(parentNode.getAttribute());
            parentNode=parentNode.getParent();
        }
        
        // Se crea ahora el array list de no usados
        ArrayList<Attribute> unused=new ArrayList<Attribute>();
        
        // Se recuperan los atributos en los datos
        Enumeration attributes=data.enumerateAttributes();
        
        // Se agregan a unused
        Attribute newAttribute;
        while(attributes.hasMoreElements()){
            newAttribute=(Attribute)attributes.nextElement();
            
            // Se comprueba si esta en used
            if (!used.contains(newAttribute)){
                unused.add(newAttribute);
            }
        }
        
        // Se devuelve el array de unused
        return unused;
    }
}
 
                
 
